{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d9be6d91",
   "metadata": {},
   "source": [
    "# Coarsened Exact Matching with Uplift estimator: Use Case and Examples\n",
    "\n",
    "Coarsened exact matching (CEM) is a widely used non-parametric matching method and is often compared to PSM.\n",
    "You need to be careful that CEM does not provide ATE estimation, because it discard both treatment group observations and control group observations. If no treated units are unmatched, you can estimate the average treatment effect on the treated (ATT). If any treated units are discarded, the estimand is the average treatment effect in the matched sample (ATM). The advantage of CEM is that it guarantees your data to be post-match balance, therefore is a good data-preprocess tool that can be used together with other estimator such as uplift.\n",
    "\n",
    "In this example, we also show how to compute uplift estimator based on post-matching data, and compare their performance.\n",
    "\n",
    "### Data\n",
    "\n",
    "CEM in settings where we have several different types of observations:\n",
    "* Covariates, which we will denote with `X`\n",
    "* Treatment, which we will denote with `T`\n",
    "* Responses, which we will denote with `Y`\n",
    "\n",
    "Requirement is that `T` is a binary varible which contain only 0/1 values.\n",
    "\n",
    "### Estimation\n",
    "\n",
    "To construct a CEM estimator, we follow following steps:\n",
    "1. We determine if X varibles you input is categorical or continuous based on X dtype: string/object are treated as categorical variables, int/float are treated as numeric type.\n",
    "2. For categorical variables, each value is seen as one bin; for continuous variable, we cut 5 percentile and treat each percentile as a bin.\n",
    "3. Finally we concatenate all bins together, and see if any bin contains only treated obs or only control obs. If so then we drop the bin.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d29182bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['/Library/Frameworks/Python.framework/Versions/3.12/lib/python312.zip', '/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12', '/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/lib-dynload', '', '/Users/bytedance/Library/Python/3.12/lib/python/site-packages', '/Library/Frameworks/Python.framework/Versions/3.12/lib/python3.12/site-packages']\n",
      "current version is:  0.0.5\n",
      "/usr/local/bin/python3.12\n",
      "3.12.2 (v3.12.2:6abddd9f6a, Feb  6 2024, 17:02:06) [Clang 13.0.0 (clang-1300.0.29.30)]\n",
      "sys.version_info(major=3, minor=12, micro=2, releaselevel='final', serial=0)\n"
     ]
    }
   ],
   "source": [
    "# Set the path of current github project folder\n",
    "# import sys\n",
    "# print(sys.path)\n",
    "# sys.path.append('/Users/bytedance/PycharmProjects/github/CausalMatch')\n",
    "\n",
    "# Import the most update version of causalmatch\n",
    "import causalmatch as causalmatch\n",
    "from causalmatch import matching, gen_test_data, gen_test_data_panel\n",
    "from causalmatch.matching.match_core.utils import data_process_bc,data_process_ate\n",
    "from causalmatch.matching.match_core.meta_learner import SMAPE\n",
    "print('current version is: ',causalmatch.__version__)\n",
    "\n",
    "# check which python jupyter notebook links to\n",
    "import sys\n",
    "print(sys.executable)\n",
    "print(sys.version)\n",
    "print(sys.version_info)\n",
    "\n",
    "# Import the rest of dependencies\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import statsmodels.api as sm\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import recall_score,roc_auc_score,f1_score\n",
    "import statsmodels.api as sm\n",
    "from matplotlib import pyplot\n",
    "from functools import reduce\n",
    "\n",
    "from sklearn.metrics import make_scorer,auc\n",
    "from sklearn.model_selection import KFold, cross_val_score\n",
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d17c520",
   "metadata": {},
   "source": [
    "## 1. generate synthetic data for example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d3f98187",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True treatment effect in data generating process is 0.5\n"
     ]
    }
   ],
   "source": [
    "df, rand_continuous, rand_true_param, param_te , rand_treatment, rand_error = gen_test_data(n = 10000, c_ratio=0.5)\n",
    "X = ['c_1','d_1','d_3']\n",
    "y = ['y']\n",
    "id = 'user_id'\n",
    "\n",
    "# treatment variable has to be a 0/1 dummy variable\n",
    "# if is string, please convert to a 0/1 int input\n",
    "T = 'treatment'\n",
    "\n",
    "print('True treatment effect in data generating process is {}'.format(param_te))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e6e5ab9",
   "metadata": {},
   "source": [
    "## 2. Matching\n",
    "### 2.1. CEM"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bf43444",
   "metadata": {},
   "source": [
    "`match_obj.hte()` returns the treatment effect from a linear single learner model \n",
    "$y=f(X,T)+\\varepsilon $, where $f(X,T)$ is a first order polynomial. For example, if $X=[X_1,X_2]$, $y=\\alpha_0+\\alpha_1 X_1 T+\\alpha_2 X_2 T+\\alpha_3 X_1 +\\alpha_4 X_2+\\alpha_5 T  +  \\varepsilon$.\n",
    "We also provide MAPE score based on linear model.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d2bb4f2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of matched obs (9768, 15) number of total obs  (10000, 15)\n",
      "   y       ate         p_val\n",
      "0  y  0.500467  1.832978e-26\n",
      "Cross Validation Scores:  [0.26 0.28 0.27 0.25 0.27]\n",
      "Average CV Score:  0.266\n",
      "Number of CV Scores used in Average:  5\n",
      "Average heterogeneous treatment effect 0.4952079535964221\n"
     ]
    }
   ],
   "source": [
    "# ---------------         CEM          --------------- #\n",
    "# STEP 1: initialize matching object\n",
    "match_obj = matching(data = df, \n",
    "                     y = y,\n",
    "                     T = T, \n",
    "                     X = X,\n",
    "                     id = 'user_id')\n",
    "\n",
    "# STEP 2: coarsened exact matching\n",
    "match_obj.cem(n_bins = 10, # number of bins you set to divide continuous variables, user pd.qcut function to obatin\n",
    "              k2k = True)  # k2k: make sure number of treatment equals number of control. if is false, you need to apply weighted least square to obtain ATE\n",
    "\n",
    "# STEP 3: balance check after propensity score matching\n",
    "res_post, res_pre = match_obj.balance_check(include_discrete=True)\n",
    "\n",
    "# STEP 4: obtain average treatment effect \n",
    "print(match_obj.ate())\n",
    "\n",
    "# STEP 5: obtain heterogeneous treatment effect based on single learner linear model\n",
    "hte_linear = match_obj.hte()\n",
    "print('Average heterogeneous treatment effect', np.mean(hte_linear))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f19e2365",
   "metadata": {},
   "source": [
    "### 2.2 PSM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6efaf87b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   y       ate         p_val\n",
      "0  y  0.470288  5.694354e-22\n",
      "Cross Validation Scores:  [0.26 0.27 0.28 0.27 0.27]\n",
      "Average CV Score:  0.27\n",
      "Number of CV Scores used in Average:  5\n",
      "Average heterogeneous treatment effect 0.4731130489784309\n"
     ]
    }
   ],
   "source": [
    "# ---------------         PSM          --------------- #\n",
    "# STEP 1: initialize matching object\n",
    "match_obj = matching(data = df,\n",
    "                     y = y,\n",
    "                     T = T,\n",
    "                     X = X,\n",
    "                     id = id)\n",
    "\n",
    "# STEP 2: propensity score matching\n",
    "match_obj.psm(n_neighbors = 1,  # number of neighbors\n",
    "              model = LogisticRegression(), # p-score model\n",
    "              trim_percentage = 0.1, # trim X% of pscore, if equals 0.1 then trim min 5% and max 5%\n",
    "              caliper = 0.1) # p-score diff must be smaller than or equal to the caliper value\n",
    "\n",
    "# STEP 3: balance check after propensity score matching\n",
    "res_post, res_pre = match_obj.balance_check(include_discrete=True)\n",
    "\n",
    "# STEP 4: obtain average treatment effect \n",
    "print(match_obj.ate())\n",
    "\n",
    "# STEP 5: obtain heterogeneous treatment effect based on single learner linear model\n",
    "hte_linear = match_obj.hte()\n",
    "print('Average heterogeneous treatment effect', np.mean(hte_linear))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a39af880",
   "metadata": {},
   "source": [
    "## 3. Model Comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc1a89f5",
   "metadata": {},
   "source": [
    "### 3.1 Model Comparison using SMAPE\n",
    "We use CausalForest from `EconML` as a comparison model to assess linear model performance in terms of both [SMAPE](https://en.wikipedia.org/wiki/Symmetric_mean_absolute_percentage_error) and AUC.\n",
    "If you want to use treatment effect to make policy inference, the accuracy of treatment effect itself is crucial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4ac8b3a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.26, 0.27, 0.28, 0.27, 0.27]\n",
      "0.27\n"
     ]
    }
   ],
   "source": [
    "from econml.grf import CausalForest\n",
    "\n",
    "# post matching data from PSM\n",
    "df_match = match_obj.df_out_final\n",
    "\n",
    "# process post-matching data to include original X and y\n",
    "X_balance_check, df_post_validate, df_pre_validate = data_process_bc(match_obj, True)\n",
    "df_post_validate_y, weight = data_process_ate(match_obj, df_post_validate)\n",
    "\n",
    "# define data to be trained\n",
    "y = match_obj.y[0]\n",
    "X_mat = df_post_validate[X_balance_check].values\n",
    "T_mat = df_post_validate[[T]].values\n",
    "y_mat = df_post_validate_y[[y]].values\n",
    "\n",
    "# CausalForest presumes that the outcome Y depends linearly on the treatment T on each leaf. \n",
    "# That means this relation is independent of the treatment T, and CATE equals\n",
    "est = CausalForest(criterion='het', \n",
    "                   n_estimators = 20, \n",
    "                   min_samples_leaf = 50, \n",
    "                   max_depth=None,\n",
    "                   min_var_fraction_leaf=None, \n",
    "                   min_var_leaf_on_val=True,\n",
    "                   min_impurity_decrease = 0.0, \n",
    "                   max_samples=0.45, \n",
    "                   min_balancedness_tol=.45,\n",
    "                   warm_start=False, \n",
    "                   inference=True, \n",
    "                   fit_intercept=True, \n",
    "                   subforest_size=4,\n",
    "                   honest=True, \n",
    "                   verbose=0, \n",
    "                   n_jobs=-1, \n",
    "                   random_state=11111)\n",
    "\n",
    "scores_cf = []\n",
    "niter = 0\n",
    "k_folds = KFold(n_splits = 5, shuffle=True, random_state=111)\n",
    "\n",
    "for train_index, test_index in k_folds.split(X_mat):\n",
    "\n",
    "    X_train_i, X_test_i = X_mat[train_index,:], X_mat[test_index,:]\n",
    "    y_train_i, y_test_i = y_mat[train_index,:], y_mat[test_index,:]\n",
    "    t_train_i, t_test_i = T_mat[train_index,:], T_mat[test_index,:]\n",
    "    \n",
    "    est.fit(X_train_i, t_train_i, y_train_i)\n",
    "    \n",
    "    point = est.predict_full(X_test_i)\n",
    "    \n",
    "    y_pred = t_test_i * point[:,0].reshape(-1,1) + point[:,1].reshape(-1,1)\n",
    "    \n",
    "    score_i = SMAPE(y_test_i, y_pred)\n",
    "    scores_cf.append(score_i)\n",
    "    niter = niter + 1\n",
    "\n",
    "\n",
    "print(scores_cf)    \n",
    "print(np.array(scores_cf).mean())\n",
    "\n",
    "hte_cf = est.predict(X_mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de2b00fa",
   "metadata": {},
   "source": [
    "### 3.2 AUC curve\n",
    "You may also want to consider using qini curve or uplift curve to assess the performance of the uplift estimator, i.e whether hte is able to select policy sensitive users from the population or not.\n",
    "Since you've already got rid of confoundness through matching, ATE from post-matching data can be used as the baseline in the Qini curve. The traditional Qini curve only deal with binary T and binary y, now we can extend Qini curve to continuous y and T.\n",
    "\n",
    "Computation steps are as follows:\n",
    "1. For every hte you obtain, cut N percentile.\n",
    "2. In each percentile, compute $ATE_i$, and compare $ATE_i$ with ATE from matching.\n",
    "3. Use ATE as benchmark, plot modified qini curve and compute AUC.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8efe20ec",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "T_mat_ = sm.add_constant(T_mat)\n",
    "model_full = sm.OLS(y_mat,T_mat_)\n",
    "results_full = model_full.fit()\n",
    "\n",
    "\n",
    "df_hte = pd.DataFrame()\n",
    "df_hte['hte_cf'] = hte_cf.flatten()\n",
    "df_hte['hte_linear'] = hte_linear.flatten()\n",
    "\n",
    "\n",
    "df_hte['y'] = y_mat\n",
    "df_hte['t'] = T_mat\n",
    "df_hte.reset_index(inplace=True,drop=True)\n",
    "\n",
    "\n",
    "n_bins = 19 \n",
    "\n",
    "df_hte['cf_bin'] = pd.qcut(df_hte['hte_cf'], n_bins)\n",
    "df_hte['linear_bin'] = pd.qcut(df_hte['hte_linear'], n_bins)\n",
    "bin_list = ['cf_bin','linear_bin']\n",
    "\n",
    "df_uplift_curve = pd.DataFrame(columns = bin_list)\n",
    "for bin_list_i in bin_list:\n",
    "\n",
    "    par_list = []\n",
    "    q_list = []    \n",
    "    for i,j in enumerate(np.sort(df_hte[bin_list_i].value_counts().index)):\n",
    "        \n",
    "        df_i = df_hte[df_hte[bin_list_i] == j].copy()\n",
    "        df_i.reset_index(inplace=True, drop=True)\n",
    "\n",
    "        Y = df_i['y']\n",
    "        X = df_i['t']\n",
    "        X = sm.add_constant(X)\n",
    "        model = sm.OLS(Y,X)\n",
    "        results = model.fit()\n",
    "\n",
    "        par_list.append(results.params['t'])\n",
    "        \n",
    "        # append last point for plot\n",
    "    par_list.append(results_full.params[1])        \n",
    "\n",
    "    par_list.insert(0, 0)    \n",
    "    df_uplift_curve[bin_list_i] = par_list\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c7c81f81",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as mtick\n",
    "import matplotlib \n",
    "\n",
    "plt.rcParams.update({'font.size': 12})\n",
    "\n",
    "fmt = '%.0f%%'\n",
    "perc = np.linspace(0,100,21)\n",
    "random = (perc/100) * results_full.params[1]\n",
    "fig = plt.figure(1, (10,6))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "ax.plot(perc, random, '--', color='yellow', linewidth=2, markersize=2, label='Random Assignment')\n",
    "ax.plot(perc, df_uplift_curve['cf_bin'].values,'--', color='blue', linewidth=2, markersize=2, label='Causal Forest')\n",
    "ax.plot(perc, df_uplift_curve['linear_bin'].values, color='red',marker='o', label='Linear Model')\n",
    "\n",
    "# plt.ylabel('some numbers')\n",
    "\n",
    "xticks = mtick.FormatStrFormatter(fmt)\n",
    "ax.xaxis.set_major_formatter(xticks)\n",
    "ax.set(xlabel='Percentile', ylabel='ATE', title='Uplift Curve - Each Percentile')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8f9cdc14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC causal forest 45.28525276552595 AUC linear 47.40082162944051\n"
     ]
    }
   ],
   "source": [
    "# AUC unnder curve\n",
    "print('AUC causal forest', auc(perc, df_uplift_curve['cf_bin'].values), \n",
    "      'AUC linear', auc(perc, df_uplift_curve['linear_bin'].values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcaa8175",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
